﻿using System;
using System.Collections.Generic;
using System.Data;

namespace Sofire.Data
{
    public partial class QueryEngineBase
    {
        /// <summary>
        /// 指示在实体填充时，是否忽略没有找到的属性。默认为 true。当该值为 false 时，则找不到属性将会引发异常。
        /// </summary>
        public static bool IgnoreUnfoundEntityProperty = true;

        #region - Entities -

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(ExecuteCommand command)
            where TEntity : new()
        {
            return new EntityCollectionResult<TEntity>(this.ExecuteTable(command));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, ExecuteParameterCollection parameters)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, params object[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, params ExecuteParameter[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, object objectInstance)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion

        #region - Entity -

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(ExecuteCommand command)
            where TEntity : new()
        {
            return new EntityResult<TEntity>(this.ExecuteTable(command));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, ExecuteParameterCollection parameters)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, params object[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, parameters));
        }
        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, params ExecuteParameter[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, object objectInstance)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion

        #region - Models -

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(ExecuteCommand command)
            where TModel : class ,IModelLoadable, new()
        {
            return ExecuteModelsByReader<TModel>(this.CreateConnection(), command);
            //var r = this.ExecuteTable(command);
            //if(r.IsFailed) return r.Exception;
            //return r.Value.CreateReadonlyEntities<List<TModel>, TModel>();
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, ExecuteParameterCollection parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, params object[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, parameters));
        }
        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, params ExecuteParameter[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, object objectInstance)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion

        #region - Model -

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public Result<TModel> ExecuteModel<TModel>(ExecuteCommand command)
            where TModel : class ,IModelLoadable, new()
        {
            return ExecuteModelByReader<TModel>(this.CreateConnection(), command);
            //var r = this.ExecuteTable(command);
            //if(r.IsFailed) return r.Exception;
            //if(r.Value.Rows.Count == 0) return new Result<TModel>();
            //return r.Value.CreateEntity<TModel>();
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, ExecuteParameterCollection parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, params object[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, params ExecuteParameter[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, object objectInstance)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion
    }

    public partial class QueryContext
    {

        #region - Entities -

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(ExecuteCommand command)
            where TEntity : new()
        {
            return new EntityCollectionResult<TEntity>(this.ExecuteTable(command));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, ExecuteParameterCollection parameters)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, params object[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, params ExecuteParameter[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义实体的集合。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public EntityCollectionResult<TEntity> ExecuteEntities<TEntity>(string commandText, object objectInstance)
            where TEntity : new()
        {
            return this.ExecuteEntities<TEntity>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion

        #region - Entity -

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(ExecuteCommand command)
            where TEntity : new()
        {
            return new EntityResult<TEntity>(this.ExecuteTable(command));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, ExecuteParameterCollection parameters)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, params object[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, parameters));
        }
        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, params ExecuteParameter[] parameters)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的实体。
        /// </summary>
        /// <typeparam name="TEntity">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public EntityResult<TEntity> ExecuteEntity<TEntity>(string commandText, object objectInstance)
            where TEntity : new()
        {
            return this.ExecuteEntity<TEntity>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion

        #region - Models -

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(ExecuteCommand command)
            where TModel : class ,IModelLoadable, new()
        {
            return this.Engine.ExecuteModelsByReader<TModel>(this.Connection, command);
            //var r = this.ExecuteTable(command);
            //if(r.IsFailed) return r.Exception;
            //return r.Value.CreateReadonlyEntities<List<TModel>, TModel>();
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, ExecuteParameterCollection parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, params object[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, parameters));
        }
        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, params ExecuteParameter[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义只读实体的集合。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public Result<List<TModel>> ExecuteModels<TModel>(string commandText, object objectInstance)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModels<TModel>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion

        #region - Model -

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="command">执行查询的命令。</param>
        public Result<TModel> ExecuteModel<TModel>(ExecuteCommand command)
            where TModel : class ,IModelLoadable, new()
        {
            return this.Engine.ExecuteModelByReader<TModel>(this.Connection, command);
            //var r = this.ExecuteTable(command);
            //if(r.IsFailed) return r.Exception;
            //if(r.Value.Rows.Count == 0) return new Result<TModel>();
            //return r.Value.CreateEntity<TModel>();
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, ExecuteParameterCollection parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">匹配 Name/Value 的参数集合或 数组。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, params object[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="parameters">参数集合。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, params ExecuteParameter[] parameters)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, parameters));
        }

        /// <summary>
        /// 执行查询，并返回自定义的只读实体。
        /// </summary>
        /// <typeparam name="TModel">实体的类型。</typeparam>
        /// <param name="commandText">Transact-SQL 语句。第一个字符为“>”时，表示一个存储过程。</param>
        /// <param name="objectInstance">任意类型的实例。</param>
        public Result<TModel> ExecuteModel<TModel>(string commandText, object objectInstance)
            where TModel : class ,IModelLoadable, new()
        {
            return this.ExecuteModel<TModel>(new ExecuteCommand(commandText, new ExecuteParameterCollection(objectInstance)));
        }

        #endregion
    }
}